package services

import (
	"fmt"
	"supershare/backend/models"
	"time"

	"github.com/beego/beego/v2/core/logs"
)

// MeituanServiceV2 优化的美团服务
type MeituanServiceV2 struct {
	BaseService
	validator *ValidationService
}

// NewMeituanServiceV2 创建新的美团服务实例
func NewMeituanServiceV2() *MeituanServiceV2 {
	return &MeituanServiceV2{
		validator: NewValidationService(),
	}
}

// GetMeituanList 获取美团配置列表（带缓存优化）
func (s *MeituanServiceV2) GetMeituanList(page, pageSize int, filters map[string]interface{}) ([]*models.Meituan, int64, error) {
	// 使用缓存或数据库查询
	return models.GetMeituanList(page, pageSize, filters)
}

// CreateMeituan 创建美团配置（带验证）
func (s *MeituanServiceV2) CreateMeituan(req *models.Meituan) (int64, error) {
	// 验证参数
	if err := s.validator.ValidateMeituan(req); err != nil {
		return 0, err
	}

	// 检查门店是否存在
	exists, err := s.CheckStoreExists(req.StoreId)
	if err != nil {
		return 0, fmt.Errorf("检查门店失败: %v", err)
	}
	if !exists {
		return 0, fmt.Errorf("门店不存在")
	}

	// 检查是否已有相同门店的配置
	existing, err := models.GetMeituanByStoreId(req.StoreId)
	if err != nil {
		return 0, fmt.Errorf("检查现有配置失败: %v", err)
	}
	if existing != nil {
		return 0, fmt.Errorf("该门店已配置美团信息")
	}

	// 设置默认值
	req.StoreName = ""
	if store, _ := models.GetStoreById(req.StoreId); store != nil {
		req.StoreName = store.Name
	}

	if req.Status == 0 {
		req.Status = 1
	}
	if req.SyncInterval <= 0 {
		req.SyncInterval = 30
	}
	req.LastSyncTime = time.Now().Unix()

	// 保存到数据库
	return models.AddMeituan(req)
}

// UpdateMeituan 更新美团配置（带验证）
func (s *MeituanServiceV2) UpdateMeituan(id int64, req *models.Meituan) error {
	// 验证参数
	if err := s.validator.ValidateMeituan(req); err != nil {
		return err
	}

	// 获取现有配置
	meituan, err := models.GetMeituanById(id)
	if err != nil {
		return fmt.Errorf("获取配置失败: %v", err)
	}
	if meituan == nil {
		return fmt.Errorf("配置不存在")
	}

	// 更新字段
	meituan.AppKey = req.AppKey
	meituan.AppSecret = req.AppSecret
	meituan.PoiId = req.PoiId
	meituan.Status = req.Status
	meituan.SyncInterval = req.SyncInterval
	if meituan.SyncInterval <= 0 {
		meituan.SyncInterval = 30
	}

	return models.UpdateMeituan(meituan)
}

// DeleteMeituan 删除美团配置
func (s *MeituanServiceV2) DeleteMeituan(id int64) error {
	meituan, err := models.GetMeituanById(id)
	if err != nil {
		return fmt.Errorf("获取配置失败: %v", err)
	}
	if meituan == nil {
		return fmt.Errorf("配置不存在")
	}

	return models.DeleteMeituan(id)
}

// GetMeituanGroupList 获取美团团购活动列表
func (s *MeituanServiceV2) GetMeituanGroupList(page, pageSize int, filters map[string]interface{}) ([]*models.MeituanGroup, int64, error) {
	return models.GetMeituanGroupList(page, pageSize, filters)
}

// CreateMeituanGroup 创建美团团购活动（带验证）
func (s *MeituanServiceV2) CreateMeituanGroup(req *models.MeituanGroup) (int64, error) {
	// 验证参数
	if err := s.validator.ValidateMeituanGroup(req); err != nil {
		return 0, err
	}

	// 检查门店是否存在
	exists, err := s.CheckStoreExists(req.StoreId)
	if err != nil {
		return 0, fmt.Errorf("检查门店失败: %v", err)
	}
	if !exists {
		return 0, fmt.Errorf("门店不存在")
	}

	// 检查美团配置是否存在
	exists, err = s.CheckMeituanConfigExists(req.StoreId)
	if err != nil {
		return 0, fmt.Errorf("检查美团配置失败: %v", err)
	}
	if !exists {
		return 0, fmt.Errorf("该门店尚未配置美团接口")
	}

	// 获取美团配置
	meituanConfig, _ := models.GetMeituanByStoreId(req.StoreId)
	if meituanConfig != nil {
		req.MeituanId = meituanConfig.Id
	}

	// 设置默认值
	if store, _ := models.GetStoreById(req.StoreId); store != nil {
		req.StoreName = store.Name
	}
	if req.Status == 0 {
		req.Status = 1
	}
	req.IsDeleted = 0
	req.LastSyncTime = time.Now().Unix()

	return models.AddMeituanGroup(req)
}

// UpdateMeituanGroup 更新美团团购活动
func (s *MeituanServiceV2) UpdateMeituanGroup(id int64, req *models.MeituanGroup) error {
	// 验证参数
	if err := s.validator.ValidateMeituanGroup(req); err != nil {
		return err
	}

	// 获取现有活动
	group, err := models.GetMeituanGroupById(id)
	if err != nil {
		return fmt.Errorf("获取活动失败: %v", err)
	}
	if group == nil {
		return fmt.Errorf("活动不存在")
	}

	// 更新字段
	group.Title = req.Title
	group.Description = req.Description
	group.OriginalPrice = req.OriginalPrice
	group.GroupPrice = req.GroupPrice
	group.MinCount = req.MinCount
	group.MaxCount = req.MaxCount
	group.StartTime = req.StartTime
	group.EndTime = req.EndTime
	group.Status = req.Status
	group.ActivityRules = req.ActivityRules
	group.ServiceTerms = req.ServiceTerms
	group.Images = req.Images
	group.MeituanGroupId = req.MeituanGroupId

	return models.UpdateMeituanGroup(group)
}

// DeleteMeituanGroup 删除美团团购活动
func (s *MeituanServiceV2) DeleteMeituanGroup(id int64) error {
	group, err := models.GetMeituanGroupById(id)
	if err != nil {
		return fmt.Errorf("获取活动失败: %v", err)
	}
	if group == nil {
		return fmt.Errorf("活动不存在")
	}

	return models.DeleteMeituanGroup(id)
}

// SyncOrdersFromAPI 从美团API同步订单（批量优化）
func (s *MeituanServiceV2) SyncOrdersFromAPI(storeId int64, meituanGroupId int64) (int, error) {
	// 获取美团配置
	meituanConfig, err := models.GetMeituanByStoreId(storeId)
	if err != nil || meituanConfig == nil {
		return 0, fmt.Errorf("美团配置不存在")
	}

	// 获取团购活动信息
	var groupActivity *models.MeituanGroup
	if meituanGroupId > 0 {
		groupActivity, err = models.GetMeituanGroupById(meituanGroupId)
		if err != nil {
			return 0, fmt.Errorf("团购活动不存在")
		}
	}

	// 设置查询时间范围（最近24小时的订单）
	endTime := time.Now()
	startTime := endTime.Add(-24 * time.Hour)

	// 获取现有订单ID用于去重
	existingOrders, err := models.GetMeituanGroupOrderIdsByStore(storeId)
	if err != nil {
		logs.Warn("获取现有订单ID失败: %v", err)
		existingOrders = make(map[string]bool)
	}

	// 调用美团API获取订单列表（这里模拟API调用）
	orders := s.fetchOrdersFromAPI(startTime, endTime)

	return s.processOrders(storeId, meituanGroupId, meituanConfig.Id, groupActivity, orders, existingOrders)
}

// fetchOrdersFromAPI 从美团API获取订单数据
func (s *MeituanServiceV2) fetchOrdersFromAPI(startTime, endTime time.Time) []map[string]interface{} {
	// 这里应该是实际的美团API调用
	// 目前返回空数组作为示例
	return []map[string]interface{}{}
}

// processOrders 处理订单数据（批量优化）
func (s *MeituanServiceV2) processOrders(storeId int64, meituanGroupId int64, meituanConfigId int64,
	groupActivity *models.MeituanGroup, orders []map[string]interface{}, existingOrders map[string]bool) (int, error) {

	count := 0
	var newOrders []*models.MeituanGroupOrder

	for _, orderData := range orders {
		orderId, ok := orderData["order_id"].(string)
		if !ok || orderId == "" {
			continue
		}

		// 检查是否已存在
		if existingOrders[orderId] {
			continue
		}

		// 检查订单类型
		orderType, _ := orderData["order_type"].(string)
		if orderType != "group" && orderType != "groupbuy" {
			continue
		}

		// 检查是否指定团购活动
		if meituanGroupId > 0 {
			dealId, _ := orderData["deal_id"].(string)
			if groupActivity != nil && dealId != groupActivity.MeituanGroupId {
				continue
			}
		}

		order := s.parseOrderData(storeId, meituanGroupId, meituanConfigId, orderData)
		if order != nil {
			newOrders = append(newOrders, order)
			count++
		}
	}

	// 批量插入新订单
	if len(newOrders) > 0 {
		if err := models.BatchAddMeituanGroupOrders(newOrders); err != nil {
			return 0, fmt.Errorf("批量保存订单失败: %v", err)
		}
	}

	return count, nil
}

// parseOrderData 解析订单数据
func (s *MeituanServiceV2) parseOrderData(storeId int64, meituanGroupId int64, meituanConfigId int64,
	orderData map[string]interface{}) *models.MeituanGroupOrder {

	orderId, ok := orderData["order_id"].(string)
	if !ok || orderId == "" {
		return nil
	}

	storeName, _ := orderData["store_name"].(string)
	if storeName == "" {
		storeName = "未知门店"
	}

	groupTitle := "美团团购商品"
	quantity := 1
	totalPrice := 0

	if items, ok := orderData["items"].([]interface{}); ok && len(items) > 0 {
		if item, ok := items[0].(map[string]interface{}); ok {
			if name, ok := item["name"].(string); ok && name != "" {
				groupTitle = name
			}
			if qty, ok := item["quantity"].(float64); ok {
				quantity = int(qty)
			}
			if price, ok := item["price"].(float64); ok {
				totalPrice = int(price * float64(quantity))
			}
		}
	}

	userName, _ := orderData["recipient_name"].(string)
	if userName == "" {
		userName = "匿名用户"
	}

	userPhone, _ := orderData["recipient_phone"].(string)

	var orderTime int64
	if timeStr, ok := orderData["create_time"].(string); ok && timeStr != "" {
		if t, err := time.Parse("2006-01-02 15:04:05", timeStr); err == nil {
			orderTime = t.Unix()
		} else {
			orderTime = time.Now().Unix()
		}
	} else {
		orderTime = time.Now().Unix()
	}

	voucherCode, _ := orderData["voucher_code"].(string)
	status, _ := orderData["status"].(string)

	return &models.MeituanGroupOrder{
		MeituanId:        meituanConfigId,
		MeituanGroupId:   meituanGroupId,
		StoreId:          storeId,
		StoreName:        storeName,
		OrderId:          orderId,
		OrderTime:        orderTime,
		GroupTitle:       groupTitle,
		UserName:         userName,
		UserPhone:        userPhone,
		Quantity:         quantity,
		TotalPrice:       totalPrice,
		Status:           status,
		ProcessStatus:    "pending",
		IsProcessed:      0,
		VoucherCode:      voucherCode,
		VoucherValidTime: time.Now().Add(30 * 24 * time.Hour).Unix(),
		IsUsed:           0,
	}
}

// ProcessMeituanGroupOrder 处理美团团购订单
func (s *MeituanServiceV2) ProcessMeituanGroupOrder(id int64, status int, remark string) error {
	order, err := models.GetMeituanGroupOrderById(id)
	if err != nil {
		return fmt.Errorf("获取订单失败: %v", err)
	}
	if order == nil {
		return fmt.Errorf("订单不存在")
	}

	if order.IsProcessed == 1 {
		return fmt.Errorf("该订单已处理，不能重复操作")
	}

	// 更新备注
	if remark != "" {
		order.Remark = remark
		if err := models.UpdateMeituanGroupOrder(order); err != nil {
			return fmt.Errorf("更新订单备注失败: %v", err)
		}
	}

	return models.ProcessMeituanGroupOrder(id, status)
}

// UseMeituanVoucher 使用美团团购券
func (s *MeituanServiceV2) UseMeituanVoucher(orderID int64, adminID int64) error {
	order, err := models.GetMeituanGroupOrderById(orderID)
	if err != nil {
		return fmt.Errorf("获取订单失败: %v", err)
	}
	if order == nil {
		return fmt.Errorf("订单不存在")
	}

	if order.IsUsed == 1 {
		return fmt.Errorf("该团购券已使用")
	}

	if order.ProcessStatus != "accepted" && order.ProcessStatus != "completed" {
		return fmt.Errorf("该团购订单尚未确认")
	}

	// 调用美团API同步使用结果
	// TODO: 实现实际的API调用

	return models.UseMeituanGroupOrder(orderID)
}

// GetOrderStatistics 获取订单统计信息
func (s *MeituanServiceV2) GetOrderStatistics(storeId int64) (map[string]interface{}, error) {
	stats, err := models.GetMeituanGroupOrderStatistics(storeId)
	if err != nil {
		return nil, fmt.Errorf("获取统计信息失败: %v", err)
	}
	return stats, nil
}

// SearchOrders 搜索美团团购订单
func (s *MeituanServiceV2) SearchOrders(params FilterParams, page, pageSize int) ([]*models.MeituanGroupOrder, int64, error) {
	filters := s.BuildFilters(params)
	page, pageSize, _ = s.validator.ValidatePaginationParams(page, pageSize)

	return models.GetMeituanGroupOrderList(page, pageSize, filters)
}
